home *** CD-ROM | disk | FTP | other *** search
/ Mac-Source 1994 July / Mac-Source_July_1994.iso / C and C++ / Text⁄Files / Regexp / try.c < prev    next >
C/C++ Source or Header  |  1991-04-10  |  5KB  |  246 lines
  1. /*
  2.  * Simple test program for regexp(3) stuff.  Knows about debugging hooks.
  3.  *
  4.  *    Copyright (c) 1986 by University of Toronto.
  5.  *    Written by Henry Spencer.  Not derived from licensed software.
  6.  *
  7.  *    Permission is granted to anyone to use this software for any
  8.  *    purpose on any computer system, and to redistribute it freely,
  9.  *    subject to the following restrictions:
  10.  *
  11.  *    1. The author is not responsible for the consequences of use of
  12.  *        this software, no matter how awful, even if they arise
  13.  *        from defects in it.
  14.  *
  15.  *    2. The origin of this software must not be misrepresented, either
  16.  *        by explicit claim or by omission.
  17.  *
  18.  *    3. Altered versions must be plainly marked as such, and must not
  19.  *        be misrepresented as being the original software.
  20.  *
  21.  * Usage: try re [string [output [-]]]
  22.  * The re is compiled and dumped, regexeced against the string, the result
  23.  * is applied to output using regsub().  The - triggers a running narrative
  24.  * from regexec().  Dumping and narrative don't happen unless DEBUG.
  25.  *
  26.  * If there are no arguments, stdin is assumed to be a stream of lines with
  27.  * five fields:  a r.e., a string to match it against, a result code, a
  28.  * source string for regsub, and the proper result.  Result codes are 'c'
  29.  * for compile failure, 'y' for match success, 'n' for match failure.
  30.  * Field separator is tab.
  31.  */
  32. #include <stdio.h>
  33. #include "regexp.h"
  34. #include    "console.h"
  35. #include    "tryproto.h"
  36. #include    "regproto.h"
  37. #include    "stdlib.h"
  38. #include    "string.h"
  39.  
  40. #ifdef ERRAVAIL
  41. char *progname;
  42. extern char *mkprogname();
  43. #endif
  44.  
  45. #ifdef DEBUG
  46. extern long regnarrate;
  47. #endif
  48.  
  49. char buf[BUFSIZ];
  50.  
  51. long errreport = 0;        /* Report errors via errseen? */
  52. char *errseen = NULL;        /* Error message. */
  53. long status = 0;            /* Exit status. */
  54.  
  55. /* ARGSUSED */
  56. main(argc, argv)
  57. int argc;
  58. char *argv[];
  59. {
  60.     regexp *r;
  61.     long i;
  62.  
  63.     argc = ccommand(&argv);
  64.     
  65. #ifdef ERRAVAIL
  66.     progname = mkprogname(argv[0]);
  67. #endif
  68.  
  69.     if (argc == 1) {
  70.         multiple();
  71.         exit(status);
  72.     }
  73.  
  74.     r = regcomp(argv[1]);
  75.     if (r == NULL)
  76.         error("regcomp failure", "");
  77. #ifdef DEBUG
  78.     regdump(r);
  79.     if (argc > 4)
  80.         regnarrate++;
  81. #endif
  82.     if (argc > 2) {
  83.         i = regexec(r, argv[2]);
  84.         printf("%d", i);
  85.         for (i = 1; i < NSUBEXP; i++)
  86.             if (r->startp[i] != NULL && r->endp[i] != NULL)
  87.                 printf(" \\%d", i);
  88.         printf("\n");
  89.     }
  90.     if (argc > 3) {
  91.         regsub(r, argv[3], buf);
  92.         printf("%s\n", buf);
  93.     }
  94.     exit(status);
  95. }
  96.  
  97. void
  98. regerror(s)
  99. char *s;
  100. {
  101.     if (errreport)
  102.         errseen = s;
  103.     else
  104.         error(s, "");
  105. }
  106.  
  107. #ifndef ERRAVAIL
  108. error(s1, s2)
  109. char *s1;
  110. char *s2;
  111. {
  112.     fprintf(stderr, "regexp: ");
  113.     fprintf(stderr, s1, s2);
  114.     fprintf(stderr, "\n");
  115.     exit(1);
  116. }
  117. #endif
  118.  
  119. long lineno;
  120.  
  121. regexp badregexp;        /* Implicit init to 0. */
  122.  
  123. multiple()
  124. {
  125.     char rbuf[BUFSIZ];
  126.     char *field[5];
  127.     char *scan;
  128.     long i;
  129.     regexp *r;
  130.     extern char *strchr();
  131.  
  132.     errreport = 1;
  133.     lineno = 0;
  134.     while (fgets(rbuf, sizeof(rbuf), stdin) != NULL) {
  135.         rbuf[strlen(rbuf)-1] = '\0';    /* Dispense with \n. */
  136.         lineno++;
  137.         scan = rbuf;
  138.         for (i = 0; i < 5; i++) {
  139.             field[i] = scan;
  140.             if (field[i] == NULL) {
  141.                 complain("bad testfile format", "");
  142.                 exit(1);
  143.             }
  144.             scan = strchr(scan, '\t');
  145.             if (scan != NULL)
  146.                 *scan++ = '\0';
  147.         }
  148.         try(field);
  149.     }
  150.  
  151.     /* And finish up with some internal testing... */
  152.     lineno = 9990;
  153.     errseen = NULL;
  154.     if (regcomp((char *)NULL) != NULL || errseen == NULL)
  155.         complain("regcomp(NULL) doesn't complain", "");
  156.     lineno = 9991;
  157.     errseen = NULL;
  158.     if (regexec((regexp *)NULL, "foo") || errseen == NULL)
  159.         complain("regexec(NULL, ...) doesn't complain", "");
  160.     lineno = 9992;
  161.     r = regcomp("foo");
  162.     if (r == NULL) {
  163.         complain("regcomp(\"foo\") fails", "");
  164.         return;
  165.     }
  166.     lineno = 9993;
  167.     errseen = NULL;
  168.     if (regexec(r, (char *)NULL) || errseen == NULL)
  169.         complain("regexec(..., NULL) doesn't complain", "");
  170.     lineno = 9994;
  171.     errseen = NULL;
  172.     regsub((regexp *)NULL, "foo", rbuf);
  173.     if (errseen == NULL)
  174.         complain("regsub(NULL, ..., ...) doesn't complain", "");
  175.     lineno = 9995;
  176.     errseen = NULL;
  177.     regsub(r, (char *)NULL, rbuf);
  178.     if (errseen == NULL)
  179.         complain("regsub(..., NULL, ...) doesn't complain", "");
  180.     lineno = 9996;
  181.     errseen = NULL;
  182.     regsub(r, "foo", (char *)NULL);
  183.     if (errseen == NULL)
  184.         complain("regsub(..., ..., NULL) doesn't complain", "");
  185.     lineno = 9997;
  186.     errseen = NULL;
  187.     if (regexec(&badregexp, "foo") || errseen == NULL)
  188.         complain("regexec(nonsense, ...) doesn't complain", "");
  189.     lineno = 9998;
  190.     errseen = NULL;
  191.     regsub(&badregexp, "foo", rbuf);
  192.     if (errseen == NULL)
  193.         complain("regsub(nonsense, ..., ...) doesn't complain", "");
  194. }
  195.  
  196. try(fields)
  197. char **fields;
  198. {
  199.     regexp *r;
  200.     char dbuf[BUFSIZ];
  201.  
  202.     errseen = NULL;
  203.     r = regcomp(fields[0]);
  204.     if (r == NULL) {
  205.         if (*fields[2] != 'c')
  206.             complain("regcomp failure in `%s'", fields[0]);
  207.         return;
  208.     }
  209.     if (*fields[2] == 'c') {
  210.         complain("unexpected regcomp success in `%s'", fields[0]);
  211.         free((char *)r);
  212.         return;
  213.     }
  214.     if (!regexec(r, fields[1])) {
  215.         if (*fields[2] != 'n')
  216.             complain("regexec failure in `%s'", "");
  217.         free((char *)r);
  218.         return;
  219.     }
  220.     if (*fields[2] == 'n') {
  221.         complain("unexpected regexec success", "");
  222.         free((char *)r);
  223.         return;
  224.     }
  225.     errseen = NULL;
  226.     regsub(r, fields[3], dbuf);
  227.     if (errseen != NULL) {
  228.         complain("regsub complaint", "");
  229.         free((char *)r);
  230.         return;
  231.     }
  232.     if (strcmp(dbuf, fields[4]) != 0)
  233.         complain("regsub result `%s' wrong", dbuf);
  234.     free((char *)r);
  235. }
  236.  
  237. complain(s1, s2)
  238. char *s1;
  239. char *s2;
  240. {
  241.     fprintf(stderr, "try: %d: ", lineno);
  242.     fprintf(stderr, s1, s2);
  243.     fprintf(stderr, " (%s)\n", (errseen != NULL) ? errseen : "");
  244.     status = 1;
  245. }
  246.